﻿<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
	<head>
		<meta charset="utf-8"/>
		<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
		<title>Последовательности. Выражения</title>

		<link rel="stylesheet" type="text/css" href="http://moodle.spb.ru/file.php/84/python/standby.css"/><!-- page style: default -->
	</head>
	<body>
		<div class='page'>
			<h2>Последовательности. Выражения</h2>
			<p>
				В этом уроке мы заканчиваем изучать типы данных языка Python, а именно рассмотрим встроенные разновидности последовательностей. А также поговорим о выражениях, которые позволяют производить бóльшую часть обработки данных.
			</p>
			<h3>Последовательности</h3>
			<p>
				В прошлый раз мы поговорили о численных типах данных, но ясно, что их часто бывает недостаточно для написания практически любой программы. Так или иначе, нам приходится работать с целыми массивами данных, различными последовательностями - будь то последовательность символов или чисел. В этом плане Python является более гибким и совершенным языком чем C или Pascal.
			</p>
			<p>
				Последовательности в Python'е представлены несколькими типами данных. Давайте рассмотрим их основные разновидности.
			</p><br/>
			<p>
				<span class="important">Тип <b>str</b> или строковый тип</span> представляет из себя последовательность <a href="http://ru.wikipedia.org/wiki/Unicode" title="Посмотреть в ВИКИ">Unicode</a>-символов. Здесь стоит отметить, что до версии 3.x язык Python поддерживал два типа строк - <a href="http://ru.wikipedia.org/wiki/Ascii" title="Посмотреть в ВИКИ">ASCII</a> и Unicode. Строка или строковый литерал записывается последовательностью символов, ограниченных либо знаком апострофа (<cite>'</cite>), либо двойными кавычками (<cite>"</cite>). Разницы между ними нет, однако необходимо всегда использовать какой-то один стиль:
				<code>
					<span style="color: #000000;">
						s1 = 'Single line string with single quote'<br/>
						s2 = "Single line string with double quote"<br/>
						s3 = 'Trouble string"<span class="error"> # Ошибка</span><br/>
					</span>
				</code>
			</p>
			<p>
				После выполнения последнего примера, интерпретатор выдаст Вам ошибку, поскольку он не может определить конец литерала.
			</p>
			<p>
				В Python есть поддержка многострочных литералов. Такие строки должны ограничиваться <u>утроенными</u> апострофами или утроенными кавычками:
				<code>
					<span style="color: #000000;">
						s4 = '''Multy line<br/>
						string<br/>
						with three single quote'''<br/>
						s5 = """Multy line<br/>
						string<br/>
						with three double quote"""<br/>
					</span>
				</code>
			</p>
			<p>
				Как и, например, в языке C, внутри строк можно использовать специальные управляющие последовательности (табуляция, переход на новую строку, код символа и другие), которые должны  задаваться обратной косой чертой (<cite>\</cite>):
				<code>
					<span style="color: #000000;">
						s6 = 'String with \\ slash'<br/>
						s7 = 'String with \n linefeed'<br/>
						s8 = "String with \t horizontal tab"<br/>
						s9 = "\u043f\u0440\u0438\u0432\u0435\u0442"<br/>
					</span>
				</code>
			</p>	
			<p>
				Бывают случаи, когда все символы, содержащиеся в строке, включая управляющие конструкции, представлялись как есть. То есть спецсимволы не интерпретировались. Подобные строки нужны, например, для записи регулярных выражений. Чтобы установить такой вот запрет, необходимо перед строкой добавить символ <cite>r</cite>:
				<code>
					<span style="color: #000000;">
						s10 = r'\n\t\n\t'<br/>
					</span>
				</code>
			</p>
			<p>
				Если попросить интерпретатор вывести эту строку, то мы не увидим ни переходов на новую строку, ни табуляций. Мы увидим то, что написали.
			</p>
			<br/>
			<p>
				<span class="important">Тип <b>list</b> - списки</span>. В языке Pascal есть тип данных "массив", который представлял последовательность элементов одного типа. В Python'е массивов нет - их место заняли списки. И если в языке C вам приходилось реализовывать функционал списка вручную, то в Python'е этот тип данных доступен "из коробки".
			</p>
			<p>
				Список представляют собой последовательность значений с произвольной длиной. Литерал списка записывается в квадратных скобках:
				<code>
					<span style="color: #000000;">
						l1 = [0, 1, 2, 3, 4]<br/>
						l2 = [2, 3, 5, 7, 11, 13, 17, 23, 27]<br/>
					</span>
				</code>
			</p>
			<p>
				При этом значения могут быть любого типа:
				<code>
					<span style="color: #000000;">
						l3 = [0, 0.5, <span style="color: #0000FF;">True</span>, 1 + 1j, <span style="color: #0000FF;">None</span>]<br/>
					</span>
				</code>
			</p>	
			<p>
				Значения могут быть даже другими последовательностями:
				<code>
					<span style="color: #000000;">
						l4 = ['String in list', [1, 2, 3], 1 + 0.5j]<br/>
					</span>
				</code>
			</p>
			<br/>
			<p>
				<span class="important">Тип <b>tuple</b>, или кортеж</span> служит для представления константной последовательности разнородных значений. Кортеж отличается от списка тем, что в него нельзя добавить новый элемент или удалить или изменить имеющийся. Литерал кортежа записывается в круглых скобках:
				<code>
					<span style="color: #000000;">
							t1 = (0, 1, 2, 3, 4)<br/>
							t2 = (0, 0.5, <span style="color: #0000FF;">True</span>, 1 + 1j, <span style="color: #0000FF;">None</span>, 'String in tuple', [1, 2, 3])<br/>
					</span>
				</code>
			</p>
			<p>
				Чтобы создать кортеж из одного элемента, необходимо после него поставить запятую:			
				<code>
					<span style="color: #000000;">
							one_item_tuple = (1,)<br/>
					</span>
				</code>
			</p>
			<p>
				Если этого не сделать, то после выполнения команды <cite>one_item_tuple = (1)</cite> имя <cite>one_item_tuple</cite> будет связано не с кортежем, а с целым числом.
			</p>
			<p>
				Кортеж можно задавать и без использования скобок, просто перечисляя все элементы через запятую:
				<code>
					<span style="color: #000000;">
						t3 = 1, 3, 'Hello!'<br/>
						t4 = 1 - 0.1j,<br/>
					</span>
				</code>
			</p>
			<p>
				Использовать синтаксис кортежей можно как в правой, так и в левой части оператора присваивания. Например, во многих языках программирования, чтобы переменные обменялись значениями, нужно было бы писать отдельную функцию для этого (а где нет шаблонов, то там и для каждого типа данных). В Python'е с помощью кортежей это делается очень просто:
				<code>
					<span style="color: #000000;">
						a = 5<br/>
						b = 7<br/>
						a, b = b, a<br/>
					</span>
				</code>
			</p>	
			<p>
				И такие операции допустимы не только для двух переменных:
				<code>
					<span style="color: #000000;">
						t5 = (1, 2, 3)<br/>
						a, b, c = t5<br/>
					</span>
				</code>
			</p>
			<p>
				Нужно лишь убедиться, что число элементов в левой части равно числу элементов в кортеже. Таким образом кортежи можно использовать, например, для возвращения нескольких значений из функции без создания дополнительных структур данных или объектов.
			</p>
			<br/>
			<p>
				<span class="important">Тип <b>dict</b> представляет словарь или ассоциативный массив</span> - последовательность пар ключ-значение, где значение однозначно определяется ключом. В качестве ключа можно использовать любой неизменяемый тип данных - числа, строки, кортежи (при этом они не должны содержать в себе списки или словари), а в качестве значения - абсолютно любой тип. Также стоит отметить, что порядок пар произволен.
			</p>
			<p>
				Литерал словаря записывается в фигурных скобках, где через запятую перечислены пары ключ-значение:
				<code>
					<span style="color: #000000;">
						d1 = {1: 2.0, 'three': <span style="color: #0000FF;">True</span>, ('tuple_key',): 'string_value'}<br/>
						d2 = {['list_key']: 'string_value'}<br/>
					</span>
				</code>
			</p>	
			<p>
				Если передать интерпретатору на выполнение вторую команду, то он ее не выполнит и выведет ошибку - нельзя в качестве ключа использовать списки.
			</p>
			<h3>Выражения</h3>
			<p>
				Синтаксис выражений у многих языков программирования примерно одинаков, так что здесь вы встретите уже знакомые Вам конструкции. Однако это не означает, что данный раздел можно пропустить, так как всё-таки это новый язык, с которым вы знакомитесь, и он имеет ряд отличительных особенностей.
			</p>
			<p>
				Для составления выражений используются операции. Ассоциативность операций в выражениях, то есть порядок выполнения, - слева направо, за одним исключением, о котором мы поговорим далее.
			</p>
			<br/>
			<p>
				Существуют следующие типы операций (каждая последующая операция имеет более низкий приоритет в выражении):
			</p>
			<table width="420px" cellpadding="0" cellspacing="0">
				<tr class="lineA head">
					<td class="left">Операция</td>
					<td>Название</td>
				</tr>
				<tr class="lineB">
					<td class="left">or</td>
					<td>Логическое ИЛИ</td>
				</tr>				
				<tr class="lineA">
					<td class="left">and</td>
					<td>Логическое И</td>
				</tr>
				<tr class="lineB">
					<td class="left">not</td>
					<td>Логическое НЕ</td>
				</tr>				
			</table>
			<code>
				<span style="color: #000000;">
					a = <span style="color: #0000FF;">True</span><br/>
					b = <span style="color: #0000FF;">False</span><br/>
					a <span style="color: #0000FF;">and</span> b   &nbsp;&nbsp;&nbsp;<span class="comment"># Интерпретатор выведет False</span><br/>
					a <span style="color: #0000FF;">or</span> b    &nbsp;&nbsp;&nbsp;<span class="comment">  # True</span><br/>
					<span style="color: #0000FF;">not</span> a     &nbsp;&nbsp;&nbsp;&nbsp;<span class="comment">  # False</span><br/>
				</span>
			</code>	
			<p>
				Результат этих операций всегда является одним из операндов.
			</p>
			<code>
				<span style="color: #000000;">
					<span class="comment">#Предположим, что у нас есть переменные с именами x и y</span><br/>
					a = x <span style="color: #0000FF;">or</span> y  &nbsp;&nbsp;<span class="comment"># Если x ложно, то в a будет записан y, иначе - x</span><br/>
					b = x <span style="color: #0000FF;">and</span> b &nbsp;<span class="comment"># Если x ложно, то в b будет записан x, иначе - y</span><br/>
					c = <span style="color: #0000FF;">not</span> x   &nbsp;&nbsp;&nbsp;<span class="comment"># True, если x ложно, иначе - False</span><br/>
				</span>
			</code>
			<p>
				В данном контексте нужно рассмотреть, как встроенные типы приводятся к логическому типу. <cite>None</cite>, любое нулевое число (<cite>0</cite>, <cite>0.0</cite> или <cite>0j</cite>), любая пустая последовательность (<cite>''</cite>, <cite>[]</cite>, <cite>()</cite>, <cite>{}</cite>) - это всегда <cite>False</cite>, во всех остальных случаях значение приводится к  <cite>True</cite>.
			</p>
			<table width="420px" cellpadding="0" cellspacing="0">
				<tr class="lineA">
					<td class="left">is, is not</td>
					<td>Проверка идентичности</td>
				</tr>
				<tr class="lineB">
					<td class="left">&lt;, &lt;=</td>
					<td>Меньше, меньше или равно</td>
				</tr>				
				<tr class="lineA">
					<td class="left">&gt;, &gt;=</td>
					<td>Больше, больше или равно</td>
				</tr>
				<tr class="lineB">
					<td class="left">!=, ==</td>
					<td>Проверка на равенство или не равенство</td>
				</tr>				
			</table>				
			<code>
				<span style="color: #000000;">
					[1, 3] <span style="color: #0000FF;">is</span> [1, 3] &nbsp;&nbsp;<span class="comment"># False, так как это два разных списка</span><br/>
					[1, 3] == [1, 3] &nbsp;&nbsp;<span class="comment"># True</span><br/>
					a = (5, "Hello")<br/>
					a <span style="color: #0000FF;">is</span> a&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># Выражение является истинным</span><br/>
					"Hi!" <span style="color: #0000FF;">is</span> "Hi!"	 &nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># True</span><br/>
					0 <span style="color: #0000FF;">is</span> <span style="color: #0000FF;">None</span>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># False</span><br/>
					0 == <span style="color: #0000FF;">None</span>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># False</span><br/>
					(5, 3) &gt; (3, 5)	 &nbsp;&nbsp;&nbsp;<span class="comment"># True - сравниваются 1-е элементы</span><br/>
					(5, 3) &gt; (5, 4)	 &nbsp;&nbsp;&nbsp;<span class="comment"># False</span><br/>
				</span>
			</code>
			<p>
				Для последовательностей справедливо то, что сравнение происходит попарно, то есть сначала сравниваются первые элементы обоих последовательностей, если их сравнение не дает результате, то сравниваются вторые элементы и так далее.
			</p>
			<p>
				В строках идёт сравнение по коду символа. Это значит, что строка <cite>'a'</cite> меньше, если можно так выразится, строки <cite>'b'</cite>, поскольку код буквы <cite>а</cite> меньше кода буквы <cite>b</cite>.
			</p>
			<p>
				Для словарей недопустимыми являются операции больше и меньше (любого типа).
			</p>
			<p>
				Операции больше, меньше и равенства для числовых типов идентичны таковым в языке C.
			</p>
			<div class="note" title="Примечание">
				Как вы заметили <cite>[1, 3] is [1, 3]</cite> - это <cite>False</cite>, а <cite>"Hi!" is "Hi!"</cite> - это <cite>True</cite>, хотя в обоих случаях операнды представляют из себя последовательности. Дело в том, что для числовых типов и для строк операции <cite>is</cite> и <cite>is not</cite> работают как операции <cite>==</cite> и <cite>!=</cite>, т.е. сравниваются значения. Если операнды списки, кортежи или словари, то сравниваются адреса объектов в памяти:
				<code>
					<span style="color: #000000;">
						'Hi!' <span style="color: #0000FF;">is</span> 'Hi!'   &nbsp;&nbsp;&nbsp;<span class="comment"># True</span><br/>
						[1, 3] <span style="color: #0000FF;">is</span> [1, 3] &nbsp;<span class="comment"># False</span><br/><br/>
						a = [1, 3]		 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># В a - адрес, ссылка на объект [1, 3]</span><br/>
						b = a &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># В b теперь содержится тот же самый адрес</span><br/>
						b &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># Будет выведено [1, 3]</span><br/>
						a <span style="color: #0000FF;">is</span> b &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># True, ибо сравниваются адреса</span><br/>
					</span>
				</code>			
			</div>
			<table width="420px" cellpadding="0" cellspacing="0">
				<tr class="lineA">
					<td class="left">|</td>
					<td>Побитовое ИЛИ</td>
				</tr>
				<tr class="lineB">
					<td class="left">^</td>
					<td>Побитовое исключающее ИЛИ (XOR)</td>
				</tr>				
				<tr class="lineA">
					<td class="left">&amp;</td>
					<td>Побитовое И</td>
				</tr>
				<tr class="lineB">
					<td class="left">&lt;&lt;, &gt;&gt;</td>
					<td>Побитовые сдвиги</td>
				</tr>
				<tr class="lineA">
					<td class="left">+, -</td>
					<td>Сложение, вычитание</td>
				</tr>
				<tr class="lineB">
					<td class="left">*, /, //, %</td>
					<td>Умножение, деление, деление с округлением, остаток</td>
				</tr>
				<tr class="lineA">
					<td class="left">+x, -x</td>
					<td>Унарные плюс и минус</td>
				</tr>
				<tr class="lineB">
					<td class="left">~x</td>
					<td>Побитовое НЕ</td>
				</tr>
				<tr class="lineA">
					<td class="left">**</td>
					<td>Возведение в степень</td>
				</tr>				
			</table>			
			<code>
				<span style="color: #000000;">
					'Hi!' <span style="color: #0000FF;">is</span> 'Hi!'   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># True</span><br/>
					2 + 2 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># 4</span><br/>
					1.5 + 2	&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># 3.5</span><br/>
					"Hello, " + "world!" &nbsp;&nbsp;<span class="comment"># "Hello, world!"</span><br/>
					[1, 2, 3] + [4, 5, 6] &nbsp;<span class="comment"># [1, 2, 3, 4, 5, 6]</span><br/>
					(1, 2) + (2, 3) &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># (1, 2, 2, 3)</span><br/>
				</span>
			</code>	
			<p>
				Особое внимание нужно уделить <b>операции деления</b>:
				<code>
					<span style="color: #000000;">
						3.0 / 2 &nbsp;<span class="comment"># 1.5</span><br/><br/>
						3 / 2 &nbsp;&nbsp;&nbsp;<span class="comment"># 1.5, оба операнда - целые числа</span><br/>
						10 / 2 &nbsp;&nbsp;<span class="comment"># 5.0, оба операнда - целые числа</span><br/><br/>
						<span class="comment"># Если при деление целых чисел необходимо получить целое число,</span><br/><span class="comment"># то нужно использовать деление с округлением:</span><br/>
						3 // 2 &nbsp;&nbsp;<span class="comment"># 1</span><br/>
						10 // 2 &nbsp;<span class="comment"># 5</span><br/>
					</span>
				</code>
			</p>
			<p>
				Стоит отметить, что последовательности (только строки, списки и кортежи) поддерживают только операции <cite>+</cite> и <cite>*</cite>. Деление, вычитание не поддерживаются. Для всех последовательностей операция <cite>+</cite> является конкатенацией (присоединением). Требуется, чтобы по обе стороны от знака <cite>+</cite> были значения одного типа, иначе интерпретатор выведет ошибку. Но если вы хотите добавить, например, в список какой-либо кортеж, достаточно оформить его в виде списка из одного элемента:
				<code>
					<span style="color: #000000;">
						['string', 2, 2.5e-1] + [(0.5 - 1.5j,)]<br/>
						[1, 2, 3] + [4]
					</span>
				</code>
			</p>	
			<p>
				Операция же <cite>*</cite> для последовательностей требует, чтобы второй операнд был целого типа, и означает повторение элементов последовательности указанное число раз:
				<code>
					<span style="color: #000000;">
						'abc' * 3 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># 'abcabcabc'</span><br/>
						[1] * 5  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># [1, 1, 1, 1, 1]</span><br/>
						(1, 2, 3) * 2  &nbsp;<span class="comment"># (1, 2, 3, 1, 2, 3)</span><br/>
					</span>
				</code>
			</p>
			<p>
				Строки, помимо операций <cite>+</cite> и <cite>*</cite>, поддерживают <cite>%</cite>. Эту операцию используют при форматировании, и она выступает в качестве некого аналога функции printf из языка C:
				<code>
					<span style="color: #000000;">
						a = 5 <br/>
						"переменная 'a' равна %d" % a<br/>
						b = 6 <br/>
						'''переменная b равна %d<br/>значение a+b равно %d''' % (a, a + b)<br/>
					</span>
				</code>
			</p>		
			<p>
				Заметьте, что после знака <cite>%</cite> следует либо один операнд, либо явно указывается кортеж. Если из последнего примера убрать скобки, интерпретатор выведет ошибку, поскольку количество аргументов в строке не соответствует количеству аргументов, следующих за знаком <cite>%</cite>, так как он посчитает данную строку одним из элементов кортежа, наравне со значением <cite>a + b</cite>.
			</p>
			<p>
				Операция возведения в степень является тем самым <b>исключением</b> из правила порядка выполнения операций. Здесь используется обратный порядок - справа налево.
				<code>
					<span style="color: #000000;">
						2 ** 100<br/>
						<span class="comment"># 1267650600228229401496703205376</span>
					</span>
				</code>
			</p>		
			<table width="420px" cellpadding="0" cellspacing="0">
				<tr class="lineA">
					<td class="left">x.атрибут</td>
					<td>Ссылка на атрибут</td>
				</tr>
				<tr class="lineB">
					<td class="left">x[индекс]</td>
					<td>Взятие элемента по индексу или по ключу</td>
				</tr>
				<tr class="lineA">
					<td class="left">x[от:до]</td>
					<td>Выделение среза (от и до)</td>
				</tr>
				<tr class="lineB">
					<td class="left">f(аргумент,...)</td>
					<td>Вызов функции</td>
				</tr>
				<tr class="lineA">
					<td class="left">( … )</td>
					<td>Скобки или кортеж</td>
				</tr>				
			</table>	
			<p>
				Взятие элемента по индексу или по ключу свойственна всем последовательностям - строкам, спискам, кортежам и словарям. В первых трёх типах используются индексы с номерами, начинающимися с 0 и до длины последовательности - 1. В словарях индексация идёт по ключам, которые задаются при создании словаря или добавления в него нового элемента:
				<code>
					<span style="color: #000000;">
						s = 'String'<br/>
						s[0]                <span class="comment"># 'S'</span><br/>
						s[10]               <span class="error"># Ошибка: нет элемента с индексом 10</span><br/>
						l = [2, 3, 5, 7, 11]<br/>
						l[1]                <span class="comment"># 3</span><br/>
						t = (5, 4, 3, 2, 1)<br/>
						t[3]                <span class="comment"># 2</span><br/>
						d = {1: 2.0, 'three': <span style="color: #0000FF;">False</span>, ('tuple_key',): ['tuple_list']}<br/>
						d[1]                <span class="comment"># 2.0</span><br/>
						d[('tuple_key',)]   <span class="comment"># ['tuple_list']</span><br/>
						d['WrongKey']       <span class="error"># Ошибка: такого ключа нет в словаре</span><br/>
					</span>
				</code>
			</p>
			<p>
				Получив элемент списка или словаря, можно ему присвоить новое значение:
				<code>
					<span style="color: #000000;">
						l[1] = 'New'<br/>
						l                   <span class="comment"># [2, 'New', 5, 7, 11]</span><br/>
						d[1] = 1.9<br/>
						d 			    <span class="comment"># {1: 1.9, 'three': False, ('tuple_key',): ['tuple_list']}</span><br/>
						t[3] = '123'      <span class="error"># Ошибка: нельзя менять значение в кортеже</span><br/>
						s[2] = ''          <span class="error"># Ошибка: нельзя менять символы в строке</span><br/>
					</span>
				</code>
			</p>
			<p>
				С помощью присваивания можно также заполнять словарь:
				<code>
					<span style="color: #000000;">
						d['WrongKey']       <span class="error"># Ошибка: такого ключа нет в словаре</span><br/>
						d['WrongKey'] = 'NotAnymore' <br/>
						d['WrongKey']       <span class="comment"># 'NotAnymore'</span><br/>
					</span>
				</code>				
			</p>
			<p>
				Отличительной особенностью Python'а от многих других языков является то, что в нем можно использовать отрицательные индексы. Тогда элементы отсчитываются с конца:
				<code>
					<span style="color: #000000;">
						l[-1] &nbsp;<span class="comment"># 11</span><br/>
						l[-2] &nbsp;<span class="comment"># 7</span><br/>
						l[-3] &nbsp;<span class="comment"># 5</span><br/>
						l[-4] &nbsp;<span class="comment"># 'New'</span><br/>
						l[-5] &nbsp;<span class="comment"># 2</span><br/>
					</span>
				</code>
			</p>
			<p>
				<span class="important">Минимальный допустимый индекс - это длина последовательности со знаком минус</span>.
			</p>
			<p>
				Из строк, списков и кортежей можно получать специальные выборки (части последовательности) - срезы. Получение среза похоже на взятие элемента по индексу. В общем случае в квадратных скобках через двоеточия нужно указать промежуток начала среза (с какого элемента), промежуток конца среза (до какого элемента) и шаг. По умолчанию значение первого параметра равно 0, второго - длине последовательности, третьего - 1:
				<code>
					<span style="color: #000000;">
						a = [0, 1, 2, 3, 4, 5]<br/>
						a[0:3]	&nbsp;<span class="comment"># [0, 1, 2]</span><br/>
						a[2:2]	&nbsp;<span class="comment"># []</span><br/>
						a[::2]	&nbsp;<span class="comment"># [0, 2, 4]</span><br/>
					</span>
				</code>
			</p>
			<p>
				Как вы, наверное, заметили, в приведённых примерах последний параметр среза, а именно шаг, опускался вместе со своим двоеточием. Мы можем не задавать любой из трёх параметров или же все сразу, но в некоторых случаях придётся расставлять лишние символы <cite>:</cite>, чтобы интерпретатор понял, какой параметр мы хотим задать.
			</p>
			<p>
				Как и при выборке по индексу, в срезах можно указывать отрицательные значения:
				<code>
					<span style="color: #000000;">
						a[-2:]	&nbsp;&nbsp;<span class="comment"># [4, 5]</span><br/>
						a[::-2]	&nbsp;<span class="comment"># [5, 3, 1], шагаем в другую сторону</span><br/>
					</span>
				</code>
			</p>
			<p>
				У некоторых значений есть различные атрибуты-методы (встроенные функции). Чтобы их посмотреть в IDLE нужно набрать литерал или связанное с ним имя, поставить точку и нажать комбинацию клавиши <cite>Ctrl+Space</cite>. Давайте для начала рассмотрим методы списков:
				<code>
					<span style="color: #000000;">	
						a.append(3)	<span class="comment"># Добавляет элемент в конец списка</span><br/>
						a               <span class="comment"># [0, 1, 2, 3, 4, 5, 3]</span><br/><br/>
						a.count(3)		<span class="comment"># Считает количество элементов равных передаваемому значению</span><br/>
						<span class="comment"># Будет выведено 2, т.к. в данном списке два элемента равных 3</span><br/><br/>
						a.extend(a)	<span class="comment"># Добавляет к концу списка все элементы другой последовательности</span><br/>
						a              	<span class="comment"># [0, 1, 2, 3, 4, 5, 3, 0, 1, 2, 3, 4, 5, 3]</span><br/><br/>
						a.index(4)		<span class="comment"># Возвращает первый найденный индекс элемента равного 4</span><br/>
						<span class="comment"># Будет выведено 4</span><br/><br/>
						a.insert(i, x)	<span class="comment"># Вставляет элемент x в i-й промежуток</span><br/>
						a.insert(1, 'str')<br/>
						a               <span class="comment"># [0, 'str', 1, 2, 3, 4, 5, 3, 0, 1, 2, 3, 4, 5, 3]</span><br/><br/>
						a.pop(i)	<span class="comment"># Возвращает элемент с индексом i и удаляет его из списка</span><br/>
						a.pop(1)        <span class="comment"># 'str'</span><br/>
						a               <span class="comment"># [0, 1, 2, 3, 4, 5, 3, 0, 1, 2, 3, 4, 5, 3]</span><br/><br/>
						a.reverse()	<span class="comment"># Разворачивает список</span><br/>
						a			<span class="comment"># [3, 5, 4, 3, 2, 1, 0, 3, 5, 4, 3, 2, 1, 0]</span><br/><br/>
						a.sort(<i>[fname]</i>)	<span class="comment"># Сортирует список. Можно указывать свою функцию сравнения fname</span><br/>
						a.sort()<br/>
						a               <span class="comment"># [0, 0, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5]</span><br/>
					</span>
				</code>
			</p>
			<p>
				Для функций <cite>pop()</cite> и <cite>sort()</cite> можно не указывать никаких аргументов. По-умолчанию <cite>pop()</cite> будет удалять и возвращать последний элемент списка, а <cite>sort()</cite> будет использовать обычное поэлементное сравнение. Здесь существует ограничение - функция сортировки может выдать ошибку, если не сможет сравнить два элемента между собой (например, словарь и комплексное число).
			</p>
			<p>
				Для кортежей доступно только две функции - <cite>index()</cite> и <cite>count()</cite>, и их смысл не изменился.
			</p>
			<p>
				<span class="important">Строки также имеют ряд собственных функций</span>. Например, с их помощью можно разбить строку на несколько подстрок, указав разделитель; или удалить из строки лишние пробелы и символы табуляции. Мы настоятельно рекомендуем вам <a href="http://docs.python.org/py3k/library/stdtypes.html#string-methods" title="Посмотреть раздел документации">ознакомится</a> с этими функциями в соответствующем разделе документации. Многие из этих функций должны быть вам уже известны.
			</p>
			<p>
				Тип dict имеет свой набор методов, из которых самыми главными являются <cite>keys()</cite> и <cite>values()</cite>. Они возвращают специальные списки всех ключей и значений соответственно. Также можно выделить функцию <cite>update(d2)</cite>, которая дополняет выбранный словарь элементами из словаря d2:
				<code>
					<span style="color: #000000;">	
						d1 = {1: "one", 2: "two"}<br/>
						d2 = {1: "newone", 3:"three"}<br/>
						d1.update(d2)		&nbsp;<span class="comment"># {1: 'newone', 2: 'two', 3: 'three'}</span><br/>
						d1.values()		&nbsp;&nbsp;&nbsp;<span class="comment"># dict_values(['newone', 'two', 'three'])</span><br/>
						d2.keys()			&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># dict_keys([1, 2, 3])</span><br/>
					</span>
				</code>
			</p>
			<div class="note" title="Важная информация">
				<p>
					При присваивании в Python'е копируется не значение, не объект, а ссылка на него, поэтому часто бывает, что на один объект в памяти существует сразу множество ссылок. Это очень хорошо, когда, например, список нужно передавать во множество функций - не происходит копирование всего списка, а копируется только ссылка на него. Но это так же может породить некоторые проблемы, например:
					<code>
						<span style="color: #000000;">
							l1 = [1, 2, 3]<br/>
							l2 = l1<br/>
							l2 <span class="comment"># [1, 2, 3]</span><br/>
							l2.append(4)<br/>
							l2 <span class="comment"># [1, 2, 3, 4]</span><br/>
							l1 <span class="comment"># [1, 2, 3, 4]</span><br/>
							<span class="comment"># Это произошло потому что l1 и l2 ссылаются на один объект<br/>
							# Это же справедливо и для словарей:</span><br/>
							d1 = {1: 1}<br/>
							d2 = d1<br/>
							d2 <span class="comment"># {1: 1}</span><br/>
							d2[2] = 2<br/>
							d2 <span class="comment"># {1: 1, 2: 2}</span><br/>
							d1 <span class="comment"># {1: 1, 2: 2}</span>
						</span>
					</code>
				</p>
				<p>
					<span class="important">Поэтому нужно внимательно следить за ссылками</span>.
				</p>
			</div>
			<hr/>
			<p>
				На этом мы завершаем рассмотрение стандартных типов данных языка Python и операций, которые мы можем с этими типами совершать. Теперь мы научились составлять выражения. Но на одних лишь выражениях далеко не уедешь, так что в следующем уроке мы познакомимся с различными управляющими конструкциями.
			</p>		
		</div>
		<div class="footer"></div>
	</body>
</html>